# -*-Tcl-*- (nolinebreak)
# Cache v1.3 created on 2026-10-14 14:39:08
set mode(C) {1.5 {source [file join $HOME "Tcl/Modes/C Modes/cMode.tcl"]} {*.c *.h *.r *.rc} {
} {
    # Script to execute at Alpha startup
}}
set mode(TeXC) {0.1.3 tetexComm.tcl {} {
    laTeXMenu
} {
    # Initialization script.
    set ::mode::interfaceNames(TeXC) "TeX Console"
    alpha::internalModes "TeXC" "TeX Console"
    # Place this here otherwise the binding won't be seen
    # since this file is never sourced.
    binding create -creator TTXC -tag "TeX" {c 't'} TeX::typeset
}}
set mode(Stta) {2.5 {source [file join $HOME "Tcl/Modes/stataMode.tcl"]} {*.do *.ado} {
    stataMenu
} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(Stta) "Stata"
    addMenu stataMenu Stata Stta
    set unixMode(stata) {Stta}
    set modeCreator(S5x8) {Stta}
}}
set mode(VB) {0.2 {source [file join $HOME "Tcl/Modes/VBMode.tcl"]} {*.bas *.frm *.cls *.vbs *.asp *.inc} {} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(VB) "Visual Basic"
}}
set mode(m4) {0.3 {source [file join $HOME "Tcl/Modes/m4Mode.tcl"]} {*.m4 *.ac *.am} {} {
    # Script to execute at Alpha startup
}}
set mode(Scil) {1.2 {source [file join $HOME "Tcl/Modes/scilabMode.tcl"]} {*.sci *.dem} {
    scilabMenu
} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(Scil) "Scilab"
    addMenu scilabMenu Scilab
	# (bd 2019-04-30) Disabled console as the pipe does not work as
	# expected with Scilab 6.0.2 (tested on High Sierra)
# 	set ::index::consoles(Scilab) Scil::displayConsole
}}
set mode(awk) {0.1 {source [file join $HOME "Tcl/Modes/awkMode.tcl"]} {*.awk *.gawk *.nawk} {} {
	set ::mode::interfaceNames(awk) "AWK"
	set unixMode(awk) awk
}}
set mode(Swft) {0.1 {source [file join $HOME "Tcl/Modes/swiftMode.tcl"]} *.swift {} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(Swft) "Swift"
    set unixMode(swift) {Swft}
}}
set mode(zsh) {0.1 {source [file join $HOME "Tcl/Modes/zshMode.tcl"]} {*.zsh .zshrc .zshenv} {} {
	set ::mode::interfaceNames(zsh) "Zsh"
	set unixMode(zsh) zsh
}}
set mode(Clan) {1.2 {source [file join $HOME "Tcl/Modes/clanMode.tcl"]} *.cha {
    clanMenu
} {
    # Script to execute at Alpha startup
    addMenu clanMenu "Clan"
}}
set mode(RPM) {1.1 {source [file join $HOME "Tcl/Modes/RPMMode.tcl"]} {*.spec *.spec.in} {} {
	set ::mode::interfaceNames(RPM) "RPM Spec"
}}
set mode(Igor) {1.2 {source [file join $HOME "Tcl/Modes/igorMode.tcl"]} {*.igor *.ipf} {
    igorMenu
} {
    # Script to execute at Alpha startup
    addMenu igorMenu Igor
    set modeCreator(IGR0) Igor
}}
set mode(rnc) {0.1 {source [file join $HOME "Tcl/Modes/rncMode.tcl"]} *.rnc {} {
    # Script to execute at Alpha startup
	set ::mode::interfaceNames(rnc) "RNC"
}}
set mode(S) {2.7 {source [file join $HOME "Tcl/Modes/sMode.tcl"]} {*.s *.R *.r} {
    sMenu
} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(S) "S+/R"
    addMenu sMenu "S+/R" S "S+/R mode for editing S+ and R scripts"
    set unixMode(splus) {S}
    set unixMode(rscript) {S}
	set ::index::consoles(R) S::displayConsole
}}
set mode(man) {0.3 {source [file join $HOME "Tcl/Modes/manMode.tcl"]} {*.n *.tmac *.1 *.2 *.3 *.4 *.5 *.6 *.7 *.8 *.9 *.1pm *.3pm} {} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(man) "Manual"
}}
set mode(Pyth) {1.1 {source [file join $HOME "Tcl/Modes/pythonMode.tcl"]} *.py {
} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(Pyth) "Python"
}}
set mode(Text) {0.2 {
    # This script will be evaluated just once.
    newPref int leftFillColumn {0} Text
    newPref var suffixString {} Text
    newPref var prefixString {> } Text
    newPref int fillColumn {75} Text
    newPref var lineBreak {1} Text
    newPref var wordBreak {\w+} Text
    
    newPref flag autoMark 0 Text
    # To automatically indent the new line produced by pressing <return>, turn
    # this item on.  The indentation amount is determined by the context||To
    # have the <return> key produce a new line without indentation, turn this
    # item off
    newPref flag indentOnReturn 0 Text
    newPref var commentsContinuation 1 Text ""  [list "only at line start" "spaces allowed" "anywhere"] index
    ;proc Text::DblClick {args} {
		eval Tcl::DblClick $args
    }
    set Text::startPara {^[ \t]*(>|$)}
    set Text::endPara {^[ \t]*(>|$)}
    set Text::commentCharacters(General) ">"
    set Text::commentCharacters(Paragraph) [list ">>" ">>" " > "]
    set Text::commentCharacters(Box) [list "+" 1 "+" 1 "-" 3 "|" "+"]

    ;proc Text::MarkFile {args} {
		win::parseArgs w {markDividers 1}
		status::msg "Marking \"[win::Tail $w]\" …"
		set pos [minPos -w $w]
		if {$markDividers} {
			set pat {^(\t  \t|[\t ]*=+[\t ]*$)}
		} else {
			set pat {^\t  \t}
		}
		set count 0
		while {![catch {search -w $w -f 1 -r 1 $pat $pos} match]} {
			lassign $match pos0 pos1
			set pos [linePos next -w $w $pos1]
			if {$markDividers &&  [regexp {^[\t ]*=+$} [string trim [text get -w $w $pos0 $pos]]]} {
				set label "----"
			} else {
				set txt [string trim [text get -w $w $pos1 $pos]]
				if {![string length $txt]} {
					continue
				} else {
					regsub -all "\t" $txt " " label
				}
			}
			set pos2 [linePos start -w $w  [pos::math -w $w [linePos start -w $w $pos1] - 1]]
			mark add -w $w $label $pos2 $pos0 $pos0
			incr count
		}
		set msg "The window \"[win::Tail $w]\" contains $count mark"
		append msg [expr {($count == 1) ? "." : "s."}]
		status::msg $msg
		return
	}
} default {} {
}}
set mode(bc) {0.2 {source [file join $HOME "Tcl/Modes/bcMode.tcl"]} {*.b *.bc} {} {
	set ::mode::interfaceNames(bc) "Bc"
	set unixMode(bc) bc
	set ::index::consoles(Bc) bc::displayConsole
}}
set mode(Objc) {1.4.2 {source [file join $HOME "Tcl/Modes/C Modes/objcMode.tcl"]} {*.m *.mm *.h *.i} {
} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(Objc) "Objective C"
}}
set mode(MATL) {3.1 {source [file join $HOME "Tcl/Modes/Matlab mode/matlabMode.tcl"]} {*.m *.M} {
    matlabMenu
} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(MATL) "Matlab"
    addMenu matlabMenu Matlab MATL
    set unixMode(matlab) MATL
	set ::index::consoles(Matlab) MATL::displayConsole
}}
set mode(Md) {0.1 markdownMode.tcl {*.md *.mkd *.mkdn *.mdown *.markdown} {
    markdownMenu
} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(Md) "Markdown"
    addMenu markdownMenu Markdown {Md Text}
}}
set mode(Diff) {6.0 {source [file join $HOME "Tcl/Modes/Diff Mode/diffMode.tcl"]} {*.diff *.patch} diffMenu {
    alpha::internalModes "Diff"
    # Add "Diff" preferences to the Package Prefs dialog.
    package::addPrefsDialog "Diff"
    
	if { $::screenWidth < 1000 } {
		# Font size used temporarily for windows being diffed.
		newPref int fontSizeWhileDiffing 9 Diff
	} else {
		# Font size used temporarily for windows being diffed.
		newPref int fontSizeWhileDiffing 12 Diff
	}
	# Automatically translate the path delimiters in diff files generated by
    # different platforms (i.e. Unix, Windows, MacClassic).
    newPref flag translatePathDelimiters 1 Diff
    # If you've imported a diff file from a different folder structure, you
    # can have this prefix removed from the paths so «ALPHA» finds your
    # files correctly.
    newPref var removeFilePrefix "" Diff
    # Automatically close document windows after the diff is complete if they
    # were not open when the diff began.
    newPref flag killWindowsWhenDone 1 Diff
    # If this option is set, don't display the differing lines (just the
    # diff codes) when comparing two files.
    newPref flag displayOnlyDiffCodes 0 Diff
    # When an external diff file is opened, display an information sheet
    # telling how to locate the left and right windows or folders
    # corresponding to this diff file.
    newPref flag showInfoOpeningExternalDiff 1 Diff
	
	# Declare the menu
    addMenu diffMenu diff Diff
}}
set mode(octave) {1.0 {source [file join $HOME "Tcl/Modes/octaveMode.tcl"]} *.m octaveMenu {
	set ::mode::interfaceNames(octave) "Octave"
    addMenu octaveMenu Octave
	set unixMode(octave) octave
	set ::index::consoles(Octave) octave::displayConsole
}}
set mode(Mf) {3.1 {source [file join $HOME "Tcl/Modes/Metafont Mode/mfMode.tcl"]} {*.mf *.pl *.vpl} mfMenu {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(Mf) "Metafont"
    addMenu mfMenu "Mf" Mf "Menu to process and edit Metafont source files"
    set unixMode(mf) Mf
}}
set mode(dtd) {0.6 {source [file join $HOME "Tcl/Modes/XML Modes/dtdMode.tcl"]} *.dtd {} {
	set ::mode::interfaceNames(dtd) "DTD"
}}
set mode(Setx) {2.8 {source [file join $HOME "Tcl/Modes/setextMode.tcl"]} {*.stx *.etx} {
    setextMenu
} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(Setx) "Setext"
    addMenu setextMenu Setext {Setx Text}
    # Insert a new option in the 'New Document' prompt.
    ;proc newSetextWindow {} {Setx::setextTemplates "" "newSetextWindow"}
    set {newDocTypes(New Setext Doc)} {newSetextWindow}
}}
set mode(HTML) {4.1 {source [file join $HOME "Tcl/Modes/HTML and CSS Modes/htmlMode.tcl"]} {*.html *.htm *.shtml} {
	cssMenu htmlEditMenu htmlUtilsMenu
} {
	addMenu htmlEditMenu
	addMenu htmlUtilsMenu
	hook::register keyboard {binding create -tag HTML {o '.'} html::electricGreater} "Canadian - CSA"
	hook::register removekeyboard {binding delete -tag HTML {o '.'} } "Canadian - CSA"
	hook::register keyboard {binding create -tag HTML {o '.'} html::electricGreater} "Canadian - ISO"
	hook::register removekeyboard {binding delete -tag HTML {o '.'}} "Canadian - ISO"
	# Add more options to the 'New Document' prompt
	;proc newHTMLDoc {} {htmlEditMenu; html::NewWithTemplate}
	;proc newHTMLDocWithContent {} {htmlEditMenu; html::NewWithContent}
	set {newDocTypes(New HTML Doc)} newHTMLDoc
	set {newDocTypes(New HTML Doc With Content)} newHTMLDocWithContent
	set {newDocTypesRequire(New HTML Doc With Content)} 1
}}
set mode(maxima) {1.1 {source [file join $HOME "Tcl/Modes/maximaMode.tcl"]} {*.mac *.mc *.max *.mx} {
    maximaMenu
} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(maxima) "Maxima"
    addMenu maximaMenu Maxima
	set ::index::consoles(Maxima) maxima::displayConsole
}}
set mode(bat) {0.4 {source [file join $HOME "Tcl/Modes/batMode.tcl"]} {*.cmd *.bat *.sys} {
    batchMenu
} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(bat) "DOS Batch"
	if {$::tcl_platform(platform) eq "windows"} {
		addMenu batchMenu "Bat"
	}   
}}
set mode(SAS) {2.5 {source [file join $HOME "Tcl/Modes/sasMode.tcl"]} *.sas {
    sasMenu
} {
    # Script to execute at Alpha startup
    addMenu sasMenu "SAS" SAS
    set unixMode(sas) {SAS}
    set modeCreator(SaS6) {SAS}
}}
set mode(Scrp) {2.5 {source [file join $HOME "Tcl/Modes/AppleScript Mode/ASmode.tcl"]} {*.applescript *.script *.scr *.scpt *.ascr} {
	appleScriptMenu
} {
    set ::mode::interfaceNames(Scrp) "AppleScript"
    addMenu appleScriptMenu AppleScript Scrp "Menu to process and edit AppleScript scripts"
    set modeCreator(ToyS) Scrp 
	set unixMode(osascript) Scrp
}}
set mode(yacc) {1.1 {source [file join $HOME "Tcl/Modes/yaccMode.tcl"]} {*.y *.yy *.ypp *.y++} {} {
	set ::mode::interfaceNames(yacc) "Yacc/Bison"
}}
set mode(Lisp) {2.5 {source [file join $HOME "Tcl/Modes/lispMode.tcl"]} {*.el *.elc *.lisp *.lsp} {
    lispMenu
} {
    # Script to execute at Alpha startup
    addMenu lispMenu "Lisp" Lisp
    set modeCreator(ROSA)   Lisp
    set modeCreator(xlsp)   Lisp
}}
set mode(Vlog) {0.3 {source [file join $HOME "Tcl/Modes/VlogMode.tcl"]} {*.v *.vmd} {} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(Vlog) "Verilog"
}}
set mode(C++) {1.4.5 {source [file join $HOME "Tcl/Modes/C Modes/c++Mode.tcl"]} {*.C *.h *.hpp *.cc *.cp *.cpp *.pch *.pch++ *.icc *.exp *.c++} {
} {
    # Script to execute at Alpha startup
}}
set mode(PS) {1.2 {source [file join $HOME "Tcl/Modes/PostScript Mode/psMode.tcl"]} {*.ps *.eps *.epsf *.afm *.pfa *.pfb *.pdf} {
    psMenu
} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(PS) "PostScript"
    addMenu psMenu "PS" PS "Menu to edit and view PostScript or Pdf files"
}}
set mode(Wiki) {{for wikiMenu menu} Wiki::initializeMode *.wiki {
	wikiMenu
} {
    # Initialization script.  Called when Alpha is first started.
    hook::register "wwwMenuInit" {WWW::defineEditUrls}
}}
set mode(Mp) {3.1 {source [file join $HOME "Tcl/Modes/Metapost Mode/mpMode.tcl"]} {*.mp *.mpx} mpMenu {
    # Script to execute at Alpha startup
	set ::mode::interfaceNames(Mp) "Metapost"
    addMenu mpMenu "Mp" Mp "Menu to process and edit Metapost source files"
    set unixMode(mp) Mp
}}
set mode(Brws) {15.3 {source [file join $HOME "Tcl/Modes/browserMode.tcl"]} {} {} {
    # Start-up script.
    set ::mode::interfaceNames(Brws) "Browser"
    alpha::internalModes "Brws" "Browser"
    # Define these variables so they can be used elsewhere after AlphaTcl has
    # been initialized but before "Brws" mode is actually loaded.
    namespace eval browse {
	variable separator [string repeat "-" 200]
	variable jumpTo    [string repeat \t 30]
	variable char \u221e
	append jumpTo $char
    }
    # "Search > Find" and "Search > Matching Lines" can either share or
    # maintain separate search pattern, word match, ignore case, and regexp
    # settings.
    newPref flag synchronizeMatchingLinesSettings "1" supersearch
}}
set mode(M2) {4.8.0 {
    # activation script, only when we first activate the mode
    M2::enterM2Mode
    m2Mode.tcl
    m2Menu.tcl
} {*.def *.DEF *.mod *.MOD *.PRJ *.DTF *.MOD.MSTR *.M2} {
    m2Menu indentUsingSpacesOnly
} {
    # This block will be automatically evaluated when Alpha starts
    # up, irrespective of whether M2 mode is ever used.
    if {${alpha::macos}} {
        # The following allows to force the activation of M2 mode
        # such as this file is scanned and mode can receive anytime
        # a message to open M2 working files
        if {[set alpha::version] >= "8.0"} {
            namespace eval M2 {}
            tclAE::installEventHandler oM2f comp M2::EventHandlerAlpha8
            # proc M2::dummyHandler {arg1 arg2} {eval M2::EventHandlerAlpha8 "$arg1" "$arg2"}
        } else {
            eventHandler oM2f comp M2::m2EventHandler
        }
    }
    
    # Do final configuration checking to ensure preconditions for M2 mode
    # if M2 is actually activated first time
    hook::register mode::init M2::initializeM2 M2
    set unixMode(modula2) {M2}
    # Ramses shell uses creator 'RAMS' for 'TEXT' and 'MoTx' (Quick
    # reference files and MDP - Model Definition Programs) files which all
    # should trigger the M2 mode, since they contain Modula-2 code
    set modeCreator(RAMS) M2
    set M2::Signature M2Md
    
    # M2 Menu
    # See <http://alphatcl.sourceforge.net/wiki/pmwiki.php/Features/BindingsQuickStart>
    if { [alpha::package vsatisfies -loose $alpha::version "8.2a1d2"] } then {
        # alertnote "New menu management - bindings reform"
        set M2::oldMenuBuildTechnique 0
    } else {
        # alertnote "Traditional menu build technique (prior bindings reform)"
        set M2::oldMenuBuildTechnique 1
    }
    addMenu m2Menu M2 "M2" "M2 mode for editing Modula-2 programs"
}}
set mode(SQL) {1.2 {source [file join $HOME "Tcl/Modes/sqlMode.tcl"]} {*.sql *.pkg} {
} {
}}
set mode(PHP) {0.2 {source [file join $HOME "Tcl/Modes/phpMode.tcl"]} {*.php *.inc} {} {
    # Script to execute at Alpha startup
}}
set mode(SPSS) {2.5 {source [file join $HOME "Tcl/Modes/spssMode.tcl"]} {*.sps *.spss *.spp} {
    spssMenu
} {
    # Script to execute at Alpha startup
    addMenu spssMenu "SPSS" SPSS
    set unixMode(spss) {SPSS}
    set modeCreator(SPSS) {SPSS}
}}
set mode(JScr) {1.2 {source [file join $HOME "Tcl/Modes/javaScriptMode.tcl"]} *.js {
    specialIndentForCaseLabel
} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(JScr) "JavaScript"
}}
set mode(Rmd) {0.1 {source [file join $HOME "Tcl/Modes/RmdMode.tcl"]} *.Rmd RmdMenu {
    # Script to execute at Alpha startup
    addMenu RmdMenu Rmd
}}
set mode(coq) {0.3 {source [file join $HOME "Tcl/Modes/coqMode.tcl"]} {*.v *.v8} coqMenu {
    # Script to execute at Alpha startup
	set ::mode::interfaceNames(coq) "Coq"
    addMenu coqMenu "Coq" coq
	set ::index::consoles(Coq) coq::start
}}
set mode(Scm) {2.4 {source [file join $HOME "Tcl/Modes/schemeMode.tcl"]} *.scm {
    schemeMenu
} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(Scm) "Scheme"
    addMenu schemeMenu "Scheme" Scm
    set modeCreator(MrEd) Scm
    set modeCreator(MrSt) Scm
    set modeCreator(MzSt) Scm
}}
set mode(f77) {2.3 {source [file join $HOME "Tcl/Modes/Fortran Modes/fortran77Mode.tcl"]} {*.f *.inc *.fcm *.for *.hpf} {
    fortran77Menu indentUsingSpacesOnly -smartPaste
} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(f77) "Fortran 77"
    set unixMode(fortran) {f77}
    addMenu fortran77Menu "F77" [list "f77"]
}}
set mode(WWW) {{for wwwMenu menu} {source [file join $HOME "Tcl/Menus/WWW menu/wwwMode.tcl"]} *.www {
    wwwMenu
} {
    # Initialization script.  Called when Alpha is first started.
    alpha::internalModes "WWW"
}}
set mode(xsl) {0.6 {source [file join $HOME "Tcl/Modes/XML Modes/xslMode.tcl"]} {*.xsl *.xslt} {} {
	set ::mode::interfaceNames(xsl) "XSL"
}}
set mode(Hask) {0.1.1 {source [file join $HOME "Tcl/Modes/haskellMode.tcl"]} {*.hs *.lhs} {
	haskellMenu indentUsingSpacesOnly
} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(Hask) "Haskell"
    addMenu haskellMenu Haskell
	set unixMode(runhaskell) Hask
	set ::index::consoles(Haskell) Hask::displayConsole
}}
set mode(Pasc) {1.1 {source [file join $HOME "Tcl/Modes/pascalMode.tcl"]} *.p {} {
    # Script to execute at Alpha startup
    set unixMode(pascal) {Pasc}
    set ::mode::interfaceNames(Pasc) "Pascal"
}}
set mode(Rdoc) {0.2 {source [file join $HOME "Tcl/Modes/RdocMode.tcl"]} *.Rd RdocMenu {
    # Script to execute at Alpha startup
    addMenu RdocMenu Rdoc
}}
set mode(CSS) {3.1 {source [file join $HOME "Tcl/Modes/HTML and CSS Modes/cssMode.tcl"]} *.css {
	cssMenu
} {
	addMenu cssMenu CSS
}}
set mode(lex) {1.1 {source [file join $HOME "Tcl/Modes/lexMode.tcl"]} {*.l *.ll *.lpp *.lex} {} {
	set ::mode::interfaceNames(lex) "Lex/Flex"
}}
set mode(Ruby) {0.2 {source [file join $HOME "Tcl/Modes/rubyMode.tcl"]} *.rb {} {
    # Script to execute at Alpha startup
}}
set mode(mapl) {1.3 {source [file join $HOME "Tcl/Modes/mapleMode.tcl"]} *.maple {
    mapleMenu
} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(mapl) "Maple"
    addMenu mapleMenu Maple mapl
    set unixMode(maple)       {mapl}
    set unixMode(maple4)      {mapl}
    set unixMode(maple6)      {mapl}
    set unixMode(maplev-4.0a) {mapl}
    set unixMode(maple7)      {mapl}
    set unixMode(maple8)      {mapl}
    set unixMode(maple9)      {mapl}
    set unixMode(maple10)     {mapl}
}}
set mode(Java) {1.4 {source [file join $HOME "Tcl/Modes/javaMode.tcl"]} {*.java *.j} {
    javaMenu
} {
    # Script to execute at Alpha startup
    addMenu javaMenu Java Java
}}
set mode(Perl) {3.7 {source [file join $HOME "Tcl/Modes/Perl Mode/perlMode.tcl"]} {*.pl *.ph *.pm} {
    perlMenu
} {
    # Script to execute at Alpha startup
    addMenu perlMenu Perl
    set unixMode(perl)    Perl
    # Make sure that we have a 'Perl::PrevScript' variable.
    ensureset Perl::PrevScript {*startup*}
    # Make sure that we have a 'PerlSearchPath' variable.
    ensureset PerlSearchPath ""
}}
set mode(sh) {2.4 {source [file join $HOME "Tcl/Modes/shScriptsMode.tcl"]} {*.csh *.tcsh *.sh *.ksh *.command} {
    shScriptsMenu
} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(sh) "Shell Scripts"
    addMenu shScriptsMenu "sh" sh
    set unixMode(csh)  {sh}
    set unixMode(tcsh) {sh}
    set unixMode(sh)   {sh}
}}
set mode(Juli) {0.1 {source [file join $HOME "Tcl/Modes/juliaMode.tcl"]} *.jl JuliaMenu {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(Juli) "Julia"
    addMenu JuliaMenu Julia
	set unixMode(julia) julia
	set ::index::consoles(Julia) Juli::displayConsole
}}
set mode(TOML) {1.0 {source [file join $HOME "Tcl/Modes/tomlMode.tcl"]} *.toml {} {
}}
set mode(Bib) {4.6 {source [file join $HOME "Tcl/Modes/BibTeX Mode/bibtexMode.tcl"]} {*.bib *.inspec *.hollis *.isi *.marc *.oclc *.ovid *.refer} { 
    bibtexMenu indentUsingSpacesOnly
    bibToHtml bibToRefer bibConvert bibDelimited
} {
    # Mode initialization script, evaluated during Alpha's startup.
    set ::mode::interfaceNames(Bib) "BibTeX"
    addMenu bibtexMenu BibTeX Bib "Menu to process and edit BibTeX files"
}}
set mode(TIP) {0.6 {source [file join $HOME "Tcl/Modes/tipMode.tcl"]} *.tip {TIPMenu indentUsingSpacesOnly} {
    # Script to execute at Alpha startup
    addMenu TIPMenu TIP TIP
    # Register a specific action for editing remote TIPs.
    set WWW::UrlActionhttp(.*/tip/edit/\[0-9\]+\$) TIP::editRemoteTIP
}}
set mode(bash) {0.2 {source [file join $HOME "Tcl/Modes/bashMode.tcl"]} *.bash {} {
	set ::mode::interfaceNames(bash) "Bash"
	set unixMode(bash) bash
}}
set mode(Ada) {1.0.4 {source [file join $HOME "Tcl/Modes/adaMode.tcl"]} {*.ada *.ads *.adb *_.a *.a} {
} {
    # Script to execute at Alpha startup
}}
set mode(Aida) {2.1 {source [file join $HOME "Tcl/Modes/aidaMode/aidaMode.tcl"]} {*.aida *.ainc *.ainp} {
	aidaMenu
} {
	addMenu aidaMenu "Aida" Aida
    # Declare a new item for the "New Document" package
	array set newDocTypes [list "Aida Doc" "Aida::newDocument"]
}}
set mode(Chng) {0.3 {source [file join $HOME "Tcl/Modes/changeLogMode.tcl"]} {} {
} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(Chng) "Change Log"
}}
set mode(xml) {1.1 {source [file join $HOME "Tcl/Modes/XML Modes/xmlMode.tcl"]} {*.xml *.manifest *.svg *.rng *.xsd *.plist *.psf} {
    xmlMenu
} {
    # Script to execute at Alpha startup.
	set ::mode::interfaceNames(xml) "XML"
    addMenu xmlMenu XML xml
}}
set mode(TeX) {6.2 latex.tcl {*.tex *.ltx *.dtx *.sty *.cls *.Rnw *.Snw *.clo *.ini *.ins *.aux *.bbl *.blg *.bst *.def *.drv *.fd *.fdd *.glo *.gls *.idx *.ilg *.ind *.lof *.log *.lot *.toc *.nw} {
    laTeXMenu
} {
    # Initialization script.  Called when Alpha is first started.
    set unixMode(latex) {TeX}
    # Reset the search path so it will be rebuilt the next time it's needed:
    set AllTeXSearchPaths {}

    # To add a new fileset type, all we have to do is this:
    fileset::registerNewType tex tex

	# Add more options to the 'New Document' prompt
    set {newDocTypes(New LaTeX Doc)} TeX::newLaTeXDocument

    # Placed these here so BibTeX mode can definitely access them.
    set texParaCommands {begin|end|(protect\\)?label|(sub)*section\*?|subfigure|paragraph|centerline|centering|caption|chapter|item|bibitem|intertext|(protect\\)?newline|includegraphics\*?}
    namespace eval TeX {
	# The display-math pattern is: whitespace-only followed by 
	# displaymath-start or displaymath-end followed by whitespace-only:
	set displayMathPat {^\s*(\$\$|\\\[)|(\$\$|\\\])[ \t]*$}
	# The close pattern is (in addition to the parenthesis closing the
	# previous part): possibly some brackets, braces, or bullets,
	# followed by whitespace-only:
	set closePat {)(\[.*\]|\{.*\}|•)*[ \t]*)+$}
	variable startPara {^[ \t]*$|\\\\[ \t]*$|(^|[^\\\r\n])%|\\h+line[ \t]*$|}
	append startPara $displayMathPat
	append startPara {|^[ \t]*(\\(} $texParaCommands $closePat
	variable endPara {^[ \t]*$|(^|[^\\\r\n])%|}
	append endPara $displayMathPat
	append endPara {|^[ \t]*(\\(} $texParaCommands $closePat
	unset displayMathPat
	unset closePat
    }
}}
set mode(Help) {9.2.4 {} {} {} {
    # Initialization script; ensure that this file is sourced.
    help.tcl
    alpha::internalModes "Help"
    hook::register openHook {Help::openHook} "Help"
}}
set mode(Tcl) {3.4 {source [file join $HOME "Tcl/Modes/TclTk Mode/tclMode.tcl"]} {*.tcl *.itcl *.tk *.itk *.tm *.decls *.msg *.tbc tclIndex* {\* Trace '*' \*} *.bench *.test} {
    tclMenu
} {
    addMenu tclMenu Tcl "Tcl" "Tcl menu\n\nfor dealing with Tcl, Tk"
    array set unixMode {
        wish Tcl
        tclsh Tcl
        itclsh Tcl
        itkwish Tcl
        prowish Tcl
        protclsh Tcl
        tclkit Tcl
        tclkitsh Tcl
    }
    
    # Colorizing routines.
    lappend tclCmdColourings Tcl::colorTclKeywords Tcl::colorTkKeywords  Tcl::colorAlphaKeywords Tcl::colorTclXKeywords Tcl::colorItclKeywords  Tcl::colorPseudoTclKeywords Tcl::colorVariables
	# Install the item in the Tools menu and define the shortcut
	set idx [menu::insertItems $menu::core(Tools) "(-  " "Tcl Shell"]
	menuItem set $menu::core(Tools) $idx -command tclShell
	binding create {c 'y'} tclShell
	set ::index::consoles(Tclsh) tclsh::displayConsole
}}
set mode(sql3) {1.0 {source [file join $HOME "Tcl/Modes/sqlite3Mode.tcl"]} {*.sqlite3 *.sql3 *.sql} {} {
	set ::mode::interfaceNames(sql3) "Sqlite3"
	set ::index::consoles(Sqlite3) sql3::displayConsole
}}
set mode(f95) {2.3 {source [file join $HOME "Tcl/Modes/Fortran Modes/fortran95Mode.tcl"]} {*.f9 *.f90 *.f95 *.f03 *.f08} {
    fortran95Menu indentUsingSpacesOnly
} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(f95) "Fortran 95"
    set unixMode(gfortran) {f95}
    set unixMode(g95) {f95}
    addMenu fortran95Menu "F95" [list "f95"]
}}
set mode(Caml) {1.1 {source [file join $HOME "Tcl/Modes/camlMode.tcl"]} {*.ml *.mli} {} {
    # Script to execute at Alpha startup
    set modeCreator(Caml) Caml
    set unixMode(caml) {Caml}
}}
set mode(make) {0.3 {source [file join $HOME "Tcl/Modes/makeMode.tcl"]} {makefile makefile.vc GNUmakefile *.mk} {} {
    # Script to execute at Alpha startup
}}
set mode(C#) {0.2 {source [file join $HOME "Tcl/Modes/c#Mode.tcl"]} *.cs {} {}}
set mode(GPLT) {2.4 {source [file join $HOME "Tcl/Modes/gnuplotMode.tcl"]} {*.gp *.gnu *.gnp *.gplt} {
    gnuplotMenu
} {
    # Script to execute at Alpha startup
    set ::mode::interfaceNames(GPLT) "Gnuplot"
    addMenu gnuplotMenu Gnuplot GPLT
	set ::index::consoles(Gnuplot) GPLT::displayConsole
}}
set mode(Plc) {1.1 {source [file join $HOME "Tcl/Modes/plcMode.tcl"]} {*.plc *.ploc} {} {}}
set mode(dot) {0.6 {source [file join $HOME "Tcl/Modes/dotMode.tcl"]} *.dot dotMenu {
    # Script to execute at Alpha startup
    addMenu dotMenu " • " dot
}}
